MacHack 1998/MacHack 1998.toast/Sessions/Why Java Sucks/Newton11/Rock.java

Text File | 1998-06-04 | 4.5 KB | 238 lines | [TEXT/R*ch]

/*
    Rock.java - A class for a ruck that sucks.

    Copyright (C) 1996-1997 by Michael J. Webb
*/

// Imports

import java.awt.Color;
import java.awt.Graphics;
import java.util.Random;

import java.io.EOFException;
import java.io.PrintStream;
import java.io.StreamTokenizer;

import NewtonCanvas;

/** A class for a rock that sucks.
 */
class Rock
{

/* Public Members. */

    public static java.util.Random rockDice = new java.util.Random();

    public double rockX;
    public double rockY;
    public double rockZ;

    public double rockOldX;
    public double rockOldY;
    public double rockOldZ;

    public double rockDx;
    public double rockDy;
    public double rockDz;

    public double rockMass;
    public int rockSize;

    public int rockId;

    public NewtonCanvas rockCanvas;

/* Public methods. */

    /** Main constructor; takes a rock ID and the parent canvas.
     */
    public Rock
    (
        int theId,
        NewtonCanvas theCanvas
    )
    {
        this.rockCanvas = theCanvas;
        this.rockId = theId;
        Rock.seed(this);
    }

    /** Main drawing method; draws an oval of the right size.
     */
    public void drawSelfShape(Graphics g)
    {

        if
            (
                (rockX >= 0.0) &&
                (rockY >= 0.0) &&
                (rockX < rockCanvas.getSize().width) &&
                (rockY < rockCanvas.getSize().height)
            )
        {
            g.setColor(Color.white);

            g.fillOval
            (
                (int)(java.lang.Math.floor(rockX)) - rockSize,
                (int)(java.lang.Math.floor(rockY)) - rockSize,
                2 * rockSize,
                2 * rockSize
            );
        }

        rockOldX = rockX;
        rockOldY = rockY;
        rockOldZ = rockZ;
    }

    /** Compute gravatational effect for the current tick and move the rock.
     */
    public void computeValues()
    {
        for (int i = 0; i < rockCanvas.myNumRocks; i++)
        {
            if (i != rockId)
            {
                this.Suck(rockCanvas.myRocks[i]);
            }
        }

        this.rockX = this.rockOldX + this.rockDx;
        this.rockY = this.rockOldY + this.rockDy;
        this.rockZ = this.rockOldZ + this.rockDz;
    }

    /** Dump a rock to a print stream.
     */
    public void store(java.io.PrintStream stream)
    {
        stream.print(rockMass);
        stream.print('\t');
        stream.print(rockX);
        stream.print('\t');
        stream.print(rockY);
        stream.print('\t');
        stream.print(rockZ);
        stream.print('\t');
        stream.print(rockDx);
        stream.print('\t');
        stream.print(rockDy);
        stream.print('\t');
        stream.print(rockDz);
        stream.println();
    }

    /** Initialize a rock from a token stream.
     */
    public void restore(StreamTokenizer tokens)
        throws EOFException
    {
        try
        {
            rockMass = readDoubleToken(tokens);
            rockX = readDoubleToken(tokens);
            rockY = readDoubleToken(tokens);
            rockZ = readDoubleToken(tokens);
            rockDx = readDoubleToken(tokens);
            rockDy = readDoubleToken(tokens);
            rockDz = readDoubleToken(tokens);

        }
        catch (Throwable e)
        {
            throw(new EOFException());
        }
    }

/* Public Static Methods. */

    /** Initializ a rock with random initial values.
     */
    public static void seed(Rock aRock)
    {
        aRock.rockX = (rockDice.nextDouble() * 300.0) + 50.0;
        aRock.rockY = (rockDice.nextDouble() * 300.0) + 50.0;
        aRock.rockZ = (rockDice.nextDouble() * 20.0) - 10.0;

        aRock.rockOldX = aRock.rockX;
        aRock.rockOldY = aRock.rockY;
        aRock.rockOldZ = aRock.rockZ;

        aRock.rockDx = rockDice.nextGaussian() * 0.5;
        aRock.rockDy = rockDice.nextGaussian() * 0.5;
        aRock.rockDz = rockDice.nextGaussian() * 0.5;

        aRock.rockMass = 1.0 + java.lang.Math.abs(rockDice.nextGaussian());
        aRock.rockMass = aRock.rockMass * aRock.rockMass;

        aRock.rockSize =
            (int)
            java.lang.Math.floor
            (
                java.lang.Math.pow(aRock.rockMass, (1.0 / 3.0))
            );
    }

/* Private methods. */

    /** Compute acceleration effect on the rock for the current frame.
     */
    private void Suck(Rock theRock)
    {
        double            distance;
        double            df;
        double            dv;
        double            dx = this.rockOldX - theRock.rockOldX;
        double            dy = this.rockOldY - theRock.rockOldY;
        double            dz = this.rockOldZ - theRock.rockOldZ;

        distance =
            java.lang.Math.max
            (
                1.0,
                java.lang.Math.sqrt((dx*dx) + (dy*dy) + (dz*dz))
            );

        dv = this.rockMass / (distance*distance);
        df = dv / distance;

        theRock.rockDx += df * dx;
        theRock.rockDy += df * dy;
        theRock.rockDz += df * dz;
    }

    /** Get a double value from a token stream.
     */
    private double readDoubleToken(StreamTokenizer tokens)
        throws EOFException
    {
        double    val = 0.0;

        try
        {
            int        tok = tokens.nextToken();

            if (tok == StreamTokenizer.TT_NUMBER)
            {
                String    token = new String(tokens.toString());
                String num = new String(token.substring(8));
                val = Double.valueOf(num).doubleValue();
            }
            else
            {
                throw(new EOFException());
            }
        }
        catch (Throwable e)
        {
            throw(new EOFException());
        }

        return val;
    }
}